package com.parking.carsystem.parkingchargesystem.activity;


import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.baidu.location.BDLocation;
import com.baidu.location.BDLocationListener;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.MapStatus;
import com.baidu.mapapi.map.MapStatusUpdateFactory;
import com.baidu.mapapi.map.MapView;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.MyLocationData;
import com.baidu.mapapi.model.LatLng;
import com.google.gson.Gson;
import com.lzy.okgo.OkGo;
import com.lzy.okgo.callback.StringCallback;
import com.lzy.okgo.model.Response;
import com.parking.carsystem.parkingchargesystem.R;
import com.parking.carsystem.parkingchargesystem.common.Constant;
import com.parking.carsystem.parkingchargesystem.module.AbsenceData;
import com.parking.carsystem.parkingchargesystem.module.LatlngModule;
import com.parking.carsystem.parkingchargesystem.view.BottomDialog;

import java.util.ArrayList;

import butterknife.BindView;
import butterknife.ButterKnife;

public class MapActivity extends BaseActivity implements View.OnClickListener, BottomDialog.ChooseTextLisenter {
    @BindView(R.id.bmapView)
    MapView bmapView;
    @BindView(R.id.back)
    ImageView back;
    @BindView(R.id.stop_car_text_address)
    TextView stopCarTextAddress;
    @BindView(R.id.car_message)
    LinearLayout carMessage;
    @BindView(R.id.setting)
    TextView setting;
    @BindView(R.id.title_bg)
    RelativeLayout titleBg;
    @BindView(R.id.parking_type)
    TextView parkingType;
    @BindView(R.id.line)
    View line;
    @BindView(R.id.parking_distance)
    TextView parkingDistance;
    @BindView(R.id.address_detailed)
    TextView addressDetailed;
    @BindView(R.id.parking_price)
    TextView parkingPrice;
    @BindView(R.id.parking_count)
    TextView parkingCount;
    @BindView(R.id.start_navigation)
    TextView startNavigation;
    private BaiduMap mBaiduMap;
    @BindView(R.id.text)
    TextView text;
    private LocationClient mLocationClient;
    public BDLocationListener myListener = new MyLocationListener();
    private MapStatus.Builder builder;
    private boolean isFirstLoc = true;
    private ArrayList<Marker> markers;
    private Marker upMarker;
    private ArrayList<AbsenceData> absenceData;
    private BottomDialog bottomDialog;
    private ArrayList<LatlngModule.DataBean> data;
    private LatlngModule.DataBean dataBean = null;
    private double latitude;
    private double longitude;

    @Override
    protected int getContentViewId() {
        return R.layout.activity_map;
    }

    @Override
    public void initView() {
        back.setOnClickListener(this);
        startNavigation.setOnClickListener(this);
        mBaiduMap = bmapView.getMap();
        //设置百度自己的默认图标显示的方法
        mBaiduMap.setMyLocationEnabled(true);
        // 构建地图状态
        builder = new MapStatus.Builder();
        initBaiDu();
        mBaiduMap.setOnMarkerClickListener(new BaiduMap.OnMarkerClickListener() {
            @Override
            public boolean onMarkerClick(Marker marker) {
                if (upMarker != null && upMarker == marker) {
//                    BitmapDescriptor bd = BitmapDescriptorFactory
//                            .fromResource(R.mipmap.tcc_icon);
//                    marker.setIcon(bd);
                    carMessage.setVisibility(View.GONE);
                    upMarker = null;
                    dataBean = null;
                    return true;
                }
                for (int i = 0; i < markers.size(); i++) {
                    Marker marker1 = markers.get(i);
                    if (marker1 == marker) {
//                        BitmapDescriptor bd = BitmapDescriptorFactory
//                                .fromResource(R.mipmap.cur_park_icon);
//                        marker.setIcon(bd);
                        upMarker = marker;
                        carMessage.setVisibility(View.VISIBLE);
                        changParkingMessage(data.get(i));
                    }
                }
                return true;
            }
        });
    }

    /**
     * 改变停车场信息
     *
     * @param dataBean
     */
    private void changParkingMessage(LatlngModule.DataBean dataBean) {
        this.dataBean = dataBean;
        stopCarTextAddress.setText(dataBean.address);
    }

    @Override
    public void initData() {
        text.setText("查找停车场");
        back.setVisibility(View.VISIBLE);
        absenceData = new ArrayList<>();
        //三种地图
        absenceData.add(new AbsenceData("高德地图", false));
        absenceData.add(new AbsenceData("百度地图", false));
        absenceData.add(new AbsenceData("腾讯地图", false));
        bottomDialog = new BottomDialog(absenceData.size(), this);
        bottomDialog.setChooseTextLisenter(this);
        bottomDialog.setBottomData(absenceData);
        listParkingLot();
    }

    /**
     * 查询停车场的信息
     */
    private void listParkingLot() {
        showLoading();
        OkGo.<String>get(Constant.url + Constant.LISTPARKINGLOT)
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        Gson gson = new Gson();
                        LatlngModule latlngModule = gson.fromJson(response.body(), LatlngModule.class);
                        if (latlngModule.code == 200) {
                            data = latlngModule.data;
                            if (data != null && data.size() > 0) {
                                for (int i = data.size() - 1; i >= 0; i--) {
                                    LatlngModule.DataBean dataBean = data.get(i);
                                    if (dataBean.lat == 0 || dataBean.lon == 0) {
                                        data.remove(dataBean);
                                    }
                                }
                            }
                         /*   LatlngModule.DataBean dataBean = new LatlngModule.DataBean();
                            dataBean.lat = 31.9941207400;
                            dataBean.lon = 118.7511599400;
                            dataBean.address = "江苏省南京市建邺区富春江东街";
                            data.add(0,dataBean);*/
                            initOverlay(data);
                        } else {
                            showToast("没有获取到停车场信息");
                        }
                        stopLoading();
                    }

                    @Override
                    public void onError(Response<String> response) {
                        stopLoading();
                    }
                });
    }

    /**
     * //设置停车场的marker
     *
     * @param data
     */
    private void initOverlay(ArrayList<LatlngModule.DataBean> data) {
        //A的悬浮物坐标
        BitmapDescriptor bd = BitmapDescriptorFactory
                .fromResource(R.mipmap.tcc_icon);
        for (LatlngModule.DataBean datum : data) {
            if (datum.lon != 0 && datum.lat != 0) {
                //经纬度正常存在
                MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(datum.lat, datum.lon)).icon(bd)
                        .zIndex(9).draggable(true);
                markerOptions.animateType(MarkerOptions.MarkerAnimateType.grow);
                Marker marker = (Marker) mBaiduMap.addOverlay(markerOptions);
                //保存mark数据
                if (markers == null) {
                    markers = new ArrayList<>();
                }
                markers.add(marker);
            }
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 在activity执行onResume时必须调用mMapView. onResume ()
        bmapView.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 在activity执行onPause时必须调用mMapView. onPause ()
        bmapView.onPause();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 在activity执行onDestroy时必须调用mMapView.onDestroy()
        bmapView.onDestroy();
        mLocationClient.stop();
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.back:
                finish();
                break;
            case R.id.start_navigation:
                bottomDialog.show();
                break;
        }
    }

    private void initBaiDu() {
        //声明LocationClient类
        mLocationClient = new LocationClient(getApplicationContext());
        //注册监听函数
        mLocationClient.registerLocationListener(myListener);
        //该类用来设置定位SDK的定位方式
        LocationClientOption option = new LocationClientOption();
        //可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);
        //可选，默认gcj02，设置返回的定位结果坐标系   返回坐标类型包括：
//        1. gcj02：国测局坐标；
//        2. bd09：百度墨卡托坐标；
//        3. bd09ll：百度经纬度坐标；
        option.setCoorType("bd09ll");
        //可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
        option.setScanSpan(10 * 1000);//10秒 10 * 1000
        //可选，设置是否需要地址信息，默认不需要 需要
        option.setIsNeedAddress(true);
        //可选，默认false,设置是否使用gps
        option.setOpenGps(true);
        //可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        option.setIsNeedLocationDescribe(true);
        //可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        option.setIgnoreKillProcess(false);
        //可选，默认false，设置是否需要过滤gps仿真结果，默认需要
        option.setEnableSimulateGps(false);
        mLocationClient.setLocOption(option);
        mLocationClient.start();
    }

    @Override
    public void chooseText(AbsenceData text) {
        if (text.text.equals("高德地图")) {
            openGaoDeMap(dataBean.lat, dataBean.lon, dataBean.address);
        } else if (text.text.equals("百度地图")) {
            openBaiduMap(dataBean.lat, dataBean.lon, dataBean.address);
        } else if (text.text.equals("腾讯地图")) {
            openTencent(dataBean.lat, dataBean.lon, dataBean.address);
        }
    }

    private class MyLocationListener implements BDLocationListener {
        @Override
        public void onReceiveLocation(BDLocation bdLocation) {
            String time = bdLocation.getTime();//获取定位时间
            //获取纬度信息
            latitude = bdLocation.getLatitude();
            //获取经度信息
            longitude = bdLocation.getLongitude();
            float radius = bdLocation.getRadius();//获取定位精准度
            String addrStr = bdLocation.getAddrStr();//获取地址信息
            String locationDescribe = bdLocation.getLocationDescribe();//位置语义化信息
            int locType = bdLocation.getLocType();//获取类型
            Log.d("baidu", "locType = " + locType + " time = " + time + " latitude = " +
                    "" + latitude + " longitude = " + longitude + " radius = " + radius +
                    " addrStr = " + addrStr + " locationDescribe = " + locationDescribe);
//            // 默认 天安门
//            LatLng center = new LatLng(latitude, longitude);
//            // 默认 11级
//            float zoom = 17.0f;
//            builder.target(center).zoom(zoom);
//            MapStatusUpdate mapStatusUpdate = MapStatusUpdateFactory.newMapStatus(builder.build());
//
//            // 设置地图状态
//            mBaiduMap.setMapStatus(mapStatusUpdate);
//            MyLocationData.Builder builder = new MyLocationData.Builder();
//            builder.latitude(latitude);
//            builder.longitude(longitude);
//            MyLocationData data = builder.build();
//            mBaiduMap.setMyLocationData(data);
            MyLocationData locData = new MyLocationData.Builder()
                    .accuracy(radius)
                    .direction(radius).latitude(latitude)
                    .longitude(longitude).build();
            mBaiduMap.setMyLocationData(locData);
            if (isFirstLoc) {
                isFirstLoc = false;
                LatLng ll = new LatLng(latitude, longitude);
                MapStatus.Builder builder = new MapStatus.Builder();
                builder.target(ll).zoom(14.0f);
                mBaiduMap.animateMapStatus(MapStatusUpdateFactory.newMapStatus(builder.build()));
            }
        }
    }

    /**
     * 打开高德地图（公交出行，起点位置使用地图当前位置）
     * <p>
     * t = 0（驾车）= 1（公交）= 2（步行）= 3（骑行）= 4（火车）= 5（长途客车）
     *
     * @param dlat  终点纬度
     * @param dlon  终点经度
     * @param dname 终点名称
     */
    private void openGaoDeMap(double dlat, double dlon, String dname) {
        if (checkMapAppsIsExist(this, "com.autonavi.minimap")) {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.setPackage("com.autonavi.minimap");
            intent.addCategory("android.intent.category.DEFAULT");
            intent.setData(Uri.parse("androidamap://route?sourceApplication=" + R.string.app_name
                    + "&sname=我的位置&dlat=" + dlat
                    + "&dlon=" + dlon
                    + "&dname=" + dname
                    + "&dev=0&m=0&t=0"));
            startActivity(intent);
        } else {
            showToast("高德地图未安装");
        }
    }

    /*
     * 打开百度地图（公交出行，起点位置使用地图当前位置）
     *
     * mode = transit（公交）、driving（驾车）、walking（步行）和riding（骑行）. 默认:driving
     * 当 mode=transit 时 ： sy = 0：推荐路线 、 2：少换乘 、 3：少步行 、 4：不坐地铁 、 5：时间短 、 6：地铁优先
     *
     * @param dlat  终点纬度
     * @param dlon  终点经度
     * @param dname 终点名称
     */
    private void openBaiduMap(double dlat, double dlon, String dname) {
        if (checkMapAppsIsExist(this, "com.baidu.BaiduMap")) {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.setData(Uri.parse("baidumap://map/direction?origin=我的位置&destination=name:"
                    + dname
                    + "|latlng:" + dlat + "," + dlon
                    + "&mode=driving&sy=3&index=0&target=1"));
            startActivity(intent);
        } else {
            showToast("百度地图未安装");
        }
    }

    /**
     * 打开腾讯地图（公交出行，起点位置使用地图当前位置）
     * <p>
     * type :
     * 路线规划方式参数：
     * 公交：bus
     * 驾车：drive
     * 步行：walk
     * 骑行：bike
     * from 起点名称
     * fromcoord 起点坐标，格式：lat,lng （纬度在前，经度在后，逗号分隔）
     * 功能参数值：CurrentLocation ：使用定位点作为起点坐标
     * 公交：type=bus，policy有以下取值
     * 0：较快捷 、 1：少换乘 、 2：少步行 、 3：不坐地铁
     * 驾车：type=drive，policy有以下取值
     * 0：较快捷 、 1：无高速 、 2：距离短
     * policy的取值缺省为0
     *
     * @param dlat  终点纬度
     * @param dlon  终点经度
     * @param dname 终点名称
     */
    private void openTencent(double dlat, double dlon, String dname) {
        if (checkMapAppsIsExist(this, "com.tencent.map")) {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.setData(Uri.parse("qqmap://map/routeplan?type=drive&from=我的位置&fromcoord=0,0"
                    + "&to=" + dname
                    + "&tocoord=" + dlat + "," + dlon
                    + "&policy=0&referer=myapp"));
            startActivity(intent);
        } else {
            showToast("腾讯地图未安装");
        }
    }

    /**
     * 检测地图应用是否安装
     *
     * @param context
     * @param packagename
     * @return
     */
    public boolean checkMapAppsIsExist(Context context, String packagename) {
        PackageInfo packageInfo;
        try {
            packageInfo = context.getPackageManager().getPackageInfo(packagename, 0);
        } catch (Exception e) {
            packageInfo = null;
            e.printStackTrace();
        }
        return packageInfo != null;
    }
}
